home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 186_01 / ded.c < prev    next >
Encoding:
C/C++ Source or Header  |  1985-08-19  |  13.3 KB  |  720 lines
  1.  
  2. /************************************************
  3. *                        *
  4. *   d/ed.c                    *
  5. *        version 1.5 12/15/84        *
  6. *        by Collin Brendemuehl        *
  7. *                        *
  8. *************************************************
  9. *    An inexpensive disk editor        *
  10. *       for use with cp/m 2.2 computers    *
  11. *    This program source code was compiled    *
  12. *       on the C/80 C compiler vers. 3.1    *
  13. *       from The Software Toolworks        *
  14. *************************************************
  15. *    NOTE:    set Cmode in your library for    *
  16. *        character i/o            *
  17. *************************************************
  18. *                        *
  19. *    As of this date, this program is    *
  20. *    hereby donated to the public domain.    *
  21. *    It is donated on the freeware concept.    *
  22. *    If you would like to make a donation    *
  23. *    for the program, please send what you    *
  24. *    feel an appropriate value to:        *
  25. *        Collin Brendemuehl        *
  26. *        721 S. Littler Place        *
  27. *        Edmond OK 73034            *
  28. *                        *
  29. *************************************************
  30. *                        *
  31. *    Its purpose is to make system use    *
  32. *    for budding hackers (in the tradi-    *
  33. *    tional sense) possible.  It should    *
  34. *    be of more functional use than DU.COM    *
  35. *                        *
  36. ************************************************/
  37.  
  38. #define NOFLOAT
  39. #include fprintf.c
  40.  
  41. unsigned drive,track,sector,block;
  42. unsigned blksz,dsm,allocated,blksec;
  43.  
  44. int maxtrk,maxsec;
  45. int *dpb1,*dpb2;
  46.  
  47. unsigned otrack,osector;
  48. int found;
  49. int list,console;
  50. int bell;
  51.  
  52. long dsksz;
  53.  
  54. char *dpb;
  55. char dma[128];
  56. char fstring[32];
  57. char hi[3];
  58. char fi[3];
  59. char buffers[128*8];
  60.  
  61. main()
  62.     {
  63.     display();        /* signon */
  64.     setup();        /* setup variables & screen */
  65.     while(1)        /* infinite loop */
  66.         {
  67.         screen();    /* display data    */
  68.         command();    /* get command    */
  69.         }
  70.     }
  71.  
  72. display()
  73.     {
  74.     putc(26,0);
  75.     locate(8,38);
  76.     fprintf(console,"D/ED");
  77.     locate(10,33);
  78.     fprintf(console,"A Disk Editor");
  79.     locate(12,39);
  80.     fprintf(console,"by");
  81.     locate(14,31);
  82.     fprintf(console,"Collin Brendemuehl");
  83.     locate(23,0);
  84.     fprintf(console,"(c) 1984 by Collin Brendemuehl");
  85.     for(maxtrk=0;maxtrk<=1000;maxtrk++)
  86.         { /* timing loop here */
  87.         time();
  88.         }
  89.     }
  90.  
  91. setup()
  92.     {
  93.     int i;
  94.     bell = 7;
  95.     list=fopen("LST:","w");
  96.  
  97.     sector=0;        /* assign sector */
  98.     drive=bdos(25,0);    /* get drive */
  99.     dpb = bdos(31,0);    /* find dpb */
  100.     dpb1 = dpb;        /* setup 2 other pointers */
  101.     dpb2 = dpb+5;
  102.  
  103.     blksec = dpb[3]+1;    /* sectors/block */
  104.     blksz = blksec*128;    /* determine block size */
  105.     maxsec = dpb1[0]-1;    /* determine max sector count */
  106.     dsm = *dpb2;        /* determine max # of blocks */
  107.     maxtrk = dpb2[4]+((dsm*blksec)/(maxsec+1));
  108.                 /* calculate # of tracks */
  109.     track = dpb2[4];    /* track # is beginning of dir */
  110.     allocated = track;    /* allocated tracks */
  111.     dsksz = maxtrk+1;    /* calculate 'K' of disk space */
  112.     dsksz *= (maxsec+1) * 128;
  113.  
  114.     putc(26,0);    /* televideo clear screen / home */
  115.     hi[0] = 27;    /* tvi half-intensity */
  116.     hi[1] = 41;
  117.     hi[2] = 0;
  118.     fi[0] = 27;    /* tvi full-intensity */
  119.     fi[1] = 40;
  120.     fi[2] = 0;
  121.  
  122.     putc(30,0);    /* home the cursor */
  123.  
  124.     sdata();    /* print disk information */
  125.  
  126.     procsec();    /* set dma,trk,sec;read sec */
  127.     }
  128.  
  129. screen()
  130.     {
  131.     int i,j;
  132.  
  133.     putc(30,0);
  134.     putc('\n',console);
  135.     putc('\n',console);
  136.     putc('\n',console);
  137.             /* print changing information */
  138.     fprintf(console,"Track           : %s%3d%s          ",hi,track,fi);
  139.     fprintf(console,"Sector          : %s%3d%s   \n",hi,sector,fi);
  140.     fprintf(console,"Block           : %s%3d%s          ",hi,block,fi);
  141.     fprintf(console,"Drive           : %s%c%s   \n",hi,drive+65,fi);
  142.             /* print the sector contents */
  143.     for(i=0;i<=127;i++)    /* 128 bytes */
  144.         {
  145.         j=i/4;        /* space every 4 bytes */
  146.         if(j*4==i) putc(' ',console);
  147.         j=i/16;
  148.         if(j*16==i)    /* contents every 16 bytes */
  149.             {
  150.             if(i)    /* if after a line is printed only */
  151.                 {
  152.                 for(j=i-16;j<i;j++)
  153.                     {
  154.                     if(dma[j]<32||dma[j]>128) putc('.',console);
  155.                     else putc(dma[j],console);
  156.                     }
  157.                 }
  158.             /* byte count of line */
  159.             fprintf(console,"\n%3d\t",i);
  160.             }
  161.         if(dma[i]<0x10) putc('0',console);
  162.         fprintf(console,"%x",dma[i]);
  163.         }
  164.     putc(' ',console);
  165.             /* last 16 bytes contents */
  166.     for(j=112;j<=127;j++)
  167.         {
  168.         if(dma[j]<32||dma[j]>128) putc('.',console);
  169.         else putc(dma[j],console);
  170.         }
  171.     /* ********** commands ************ */
  172.     putc('\n',console);
  173.     fprintf(console,"Commands: \tQ%suit%s\n",hi,fi);
  174.     fprintf(console,"\tSector: +%sNext  %s-%sPrev%s",hi,fi,hi,fi);
  175.     fprintf(console,"   0%s %s2%s %sZ%sap%s\n",hi,fi,hi,fi,hi,fi);
  176.     fprintf(console,"\t        W%srite  %sE%sdit%s",hi,fi,hi,fi);
  177.     fprintf(console,"C%sall    %sR%secall%s\n",hi,fi,hi,fi);
  178.     fprintf(console,"\tTrack : B%sack   %sA%shead  %sH%some%s\n",hi,fi,hi,fi,hi,fi);
  179.     fprintf(console,"\tSelect: T%srack  %sS%sector%s\n",hi,fi,hi,fi);
  180.     fprintf(console,"\tDisk  : D%srive Logged%s\n",hi,fi);
  181.     fprintf(console,"\tSearch: L%socate %s*%sAgain%s\n",hi,fi,hi,fi);
  182.     fprintf(console,"\tOther : P%srint   %sF%sile%s\n",hi,fi,hi,fi);
  183.  
  184.     nline();
  185.     fprintf(console,"\t\t\t\tOption: ");
  186.     }
  187.  
  188. command()
  189.     {
  190.     int comm;
  191.  
  192.     comm=getc(0);        /* get a command character */
  193.     switch(toupper(comm))
  194.         {
  195.         default:    /* any other key */
  196.             putc(8,0);
  197.             command();
  198.             break;
  199.         case '*':    /* locate again */
  200.             star();
  201.             break;
  202.         case '2':    /* goto middle of sector */
  203.             midsec();
  204.             procsec();
  205.             break;
  206.         case '0':    /* goto beginning of sector */
  207.             begsec();
  208.             procsec();
  209.             break;
  210.         case '+':    /* next sector */
  211.             nxtsec();
  212.             procsec();
  213.             break;
  214.         case '-':    /* previous sector */
  215.             prvsec();
  216.             procsec();
  217.             break;
  218.         case 'A':    /* ahead track */
  219.             aheadt();
  220.             procsec();
  221.             break;
  222.         case 'B':    /* back track */
  223.             backt();
  224.             procsec();
  225.             break;
  226.         case 'C':    /* store sector in a buffer */
  227.             storsec();
  228.             break;    
  229.         case 'D':    /* change logged drive */
  230.             logdrv();
  231.             procsec();
  232.             break;
  233.         case 'E':    /* edit sector contents */
  234.             edit();
  235.             break;
  236.         case 'F':    /* disk files ts0.dat to ts9.dat */
  237.             fileit();
  238.             break;
  239.         case 'H':    /* home the disk head */
  240.             homehd();
  241.             procsec();
  242.             break;
  243.         case 'L':    /* locate string/data */
  244.             locdata();
  245.             break;    
  246.         case 'P':    /* print to the printer */
  247.             printit();
  248.             break;
  249.         case 'Q':    /* quit */
  250.             exit();
  251.             break;
  252.         case 'R':    /* recall sector from buffer */
  253.             recsec(); 
  254.             break;    
  255.         case 'S':    /* specific sector */
  256.             sect();
  257.             procsec();
  258.             break;
  259.         case 'T':
  260.             trak();    /* specific track */
  261.             procsec();
  262.             break;
  263.         case 'W':    /* write sector to disk */
  264.             wrsec();         
  265.             break;
  266.         case 'Z':    /* zap the sector */
  267.             zapsec();
  268.             break;
  269.         }
  270.     }
  271.  
  272. aheadt()    /* go ahead a track */
  273.     {
  274.     if(track==maxtrk) track=0;
  275.     else track++;
  276.     }
  277.  
  278. backt()        /* go back a track */
  279.     {
  280.     if(track==0) track=maxtrk;
  281.     else track--;
  282.     }
  283.  
  284. begsec()    /* goto beginning of sector */
  285.     {
  286.     sector = 0;
  287.     }
  288.  
  289. logdrv()    /* change logged drive */
  290.     {
  291.     char drv;
  292.  
  293.     nline();
  294.     fprintf(console,"\t\t\t\t  Drive :  \b");
  295.     drv=getc(0);
  296.     drv=toupper(drv);
  297.     if(drv<'A'||drv>'P') return;    /* out of range */
  298.     drv -= 'A';
  299.     drive = drv;    /* show logged drive */
  300.     chngdr(drv);    /* do the change */
  301.     setup();    /* recalculate for the drive */
  302.     }
  303.  
  304. edit()    /* edit sector contents */
  305.     {
  306.     int off,i,input;
  307.     char buff[4];
  308.  
  309.     off=offset();
  310.     for(i=off;i<=127;i++)
  311.         {
  312.         nline();
  313.         fprintf(console,"\t\t\t\t  Data[%3x]: %x   ",i,dma[i]);
  314.         input = valdata();
  315.         switch(input)
  316.             {
  317.             case -1:
  318.                 break;
  319.             case -2:
  320.                 nline();
  321.                 return ;
  322.                 break;
  323.             default:
  324.                 dma[i]=input;
  325.                 screen();
  326.                 break;
  327.             }                            
  328.         }
  329.     }
  330.  
  331. fileit()
  332.     {
  333.     static int dfile;
  334.     static char countr = 8;
  335.     static char tens = 9;
  336.     static char *fname=" :TS  .DAT";
  337.  
  338.     countr++;
  339.     if(countr>9) countr= 0;
  340.  
  341.     if(countr==0) tens++;
  342.  
  343.     if(tens>9)
  344.         {
  345.         locate(22,0);
  346.         printf("No more files available %c %c %c",bell,bell,bell);
  347.         time();
  348.         return;
  349.         }
  350.  
  351.     fname[0] = drive+65;
  352.     fname[5]=countr+0x30;
  353.     fname[4]=tens+0x30;
  354.  
  355.     dfile=fopen(fname,"w");
  356.     console=dfile;
  357.     sdata();
  358.     screen();
  359.     putc(26,dfile);
  360.     console=0;
  361.     fclose(dfile);
  362.     }
  363.  
  364. homehd()    /* goto track 0, sector 0 */
  365.     {
  366.     track=0;
  367.     sector=0;
  368.     }
  369.  
  370. star()        /* locate string a second time */
  371.     {
  372.     int i,f;
  373.  
  374.     f=0;
  375.     otrack=track;
  376.     osector=sector;
  377.     nline();
  378.     i = -1;
  379.     while((i=substr(fstring))==-1)
  380.         {
  381.         if(track==maxtrk && sector==maxsec)
  382.             break;
  383.         nxtsec();
  384.         procsec();
  385.         }
  386.     nline();
  387.     if(i == -1)
  388.         {
  389.         fprintf(console,"String Not Found");
  390.         track=otrack;
  391.         sector=osector;
  392.         }
  393.     else    {
  394.         fprintf(console,"String Found At Location %d",i);
  395.         }
  396.     procsec();
  397.     oline();
  398.     }
  399.  
  400. locdata()    /* locate data in sector */
  401.     {
  402.     int i;
  403.  
  404.     otrack=track;
  405.     osector=sector;
  406.     nline();
  407.     fprintf(console,"\t\tString (ascii) to Locate . . .");
  408.     putc('\n',0);
  409.     getline(fstring,30);
  410.     i = -1;
  411.     while((i=substr(fstring))==-1)
  412.         {
  413.         if(track==maxtrk && sector==maxsec)
  414.             break;
  415.         nxtsec();
  416.         procsec();
  417.         }
  418.     nline();
  419.     if(i == -1)
  420.         {
  421.         fprintf(console,"String Not Found");
  422.         track=otrack;
  423.         sector=osector;
  424.         }
  425.     else    {
  426.         fprintf(console,"String Found At Location %d",i);
  427.         found=i;
  428.         }
  429.     procsec();
  430.     oline();
  431.     }
  432.  
  433. midsec()    /* goto middle of sector */
  434.     {
  435.     sector=maxsec/2;
  436.     }
  437.  
  438. nxtsec()    /* goto next sector */
  439.     {
  440.     sector++;
  441.     if(sector > maxsec)
  442.         {
  443.         sector=0;
  444.         track++;
  445.         }
  446.     if(track>maxtrk) track=0;
  447.     }
  448.  
  449. prvsec()    /* goto previous sector */
  450.     {
  451.     sector--;
  452.     if(sector == -1)
  453.         {
  454.         sector=maxsec;
  455.         track--;
  456.         }
  457.     if(track == -1) track=maxtrk;
  458.     }
  459.  
  460. printit()
  461.     {
  462.     console=list;
  463.     sdata();
  464.     screen();
  465.     list=0;
  466.     }
  467.  
  468. storsec()    /* store sector in buffer */
  469.     {
  470.     int buff;
  471.     int i;
  472.  
  473.     nline();
  474.     fprintf(console,"\t\t\t\tBuffer: ");
  475.     buff=getc(0);
  476.     if(buff<'1' || buff>'8') return;
  477.     buff = buff - 0x31;
  478.     buff = buff * 0x80;
  479.     for(i=buff;i<=buff+127;i++) buffers[i]=dma[i-buff];
  480.     }
  481.  
  482. recsec()    /* recall sector from buffer */
  483.     {
  484.     int buff;
  485.     int i;
  486.     nline();
  487.     fprintf(console,"\t\t\t\tBuffer: ");
  488.     buff=getc(0);
  489.     if(buff<'1' || buff>'8') return;
  490.     buff = buff-49;
  491.     buff *= 128;
  492.     for(i=buff;i<=buff+127;i++) dma[i-buff]=buffers[i];
  493.     }
  494.  
  495. sect()
  496.     {
  497.     int i;
  498.     char seclin[8];
  499.  
  500.     nline();
  501.     fprintf(console,"\t\t\t\tSector: ");
  502.     getline(seclin,5);
  503.     i=atoi(seclin);
  504.     if(i>maxsec) sect();
  505.     if(i<0) sect();
  506.     sector=i;
  507.     }
  508.  
  509. trak()
  510.     {
  511.     int i;
  512.     char trklin[8];
  513.  
  514.     nline();
  515.     fprintf(console,"\t\t\t\t Track: ");
  516.     getline(trklin,5);
  517.     i=atoi(trklin);
  518.     if(i>maxtrk) trak();
  519.     if(i<0) trak();
  520.     track=i;
  521.     }
  522.  
  523. wrsec()        /* bios call to write sector */
  524.     {
  525.     #asm
  526.     MVI    C,0
  527.     LXI    D,39
  528.     LHLD    0001
  529.     DAD    D
  530.     PCHL
  531.     #endasm
  532.     }
  533.  
  534. zapsec()
  535.     {
  536.     int i;
  537.  
  538.     for(i=0;i<=127;i++) dma[i] = 0xe5;
  539.     }
  540.  
  541. procsec()
  542.     {
  543.     bdos(26,dma);    /* set dma address */
  544.     settrk(track);    /* set the track */
  545.     setsec(sector);    /* set the sector */
  546.     readsec();    /* read the sector */
  547.         /* calculate block number if in data area */
  548.     if(track>=allocated) block=(((track-allocated)*(maxsec+1))+sector)/blksec;
  549.     else block = 0;
  550.     }
  551.  
  552. locate(row,col)        /* column,row positioning (televideo) */
  553.     int row,col;
  554.     {
  555.     fprintf(console,"%c%c%c%c",0x1b,'=',row+32,col+32);
  556.     }
  557.  
  558. offset()        /* returns byte offset for sector editing */
  559.     {
  560.     char offst[4];
  561.  
  562.     nline();
  563.     fprintf(console,"\t\t\t\t Offset: ");
  564.     getline(offst,4);
  565.     return(atoi(offst));
  566.     }
  567.  
  568. valdata()        /* gets valid data input for sector */
  569.     {
  570.     char secdat[5];
  571.  
  572.     getline(secdat,4);
  573.     if(strlen(secdat)==0) return -1;
  574.     if(secdat[0]=='.') return -2;
  575.     if(strlen(secdat)>2) valdata();
  576.     if(secdat[0] == '#')
  577.         return secdat[1];
  578.     else
  579.         return(htoi(secdat));
  580.     }
  581.  
  582. sdata()
  583.     {
  584.     fprintf(console,"Tracks/disk     : %s%3d%s          ",hi,maxtrk+1,fi);
  585.     fprintf(console,"Block Size      : %s%4d%s  \n",hi,blksz,fi);
  586.     fprintf(console,"Sectors/track   : %s%3d%s          ",hi,maxsec+1,fi);
  587.     fprintf(console,"Blocks/disk     : %s%4d%s  \n",hi,dsm,fi);
  588.     fprintf(console,"Allocated tracks: %s%3d%s          ",hi,dpb2[4],fi);
  589.     fprintf(console,"Space on disk   : %s%ld%s  \n",hi,dsksz,fi);
  590.     }
  591.  
  592. substr(findit)
  593.     char *findit;
  594.     {
  595.     int i,j,k;
  596.  
  597.     for(i=0;i<127-strlen(findit);i++)
  598.         {
  599.         if(findit[0]==dma[i])
  600.             {
  601.             k=1;
  602.             j=0;
  603.             while(findit[j])
  604.                 {
  605.                 if(findit[j]!=dma[i+j])
  606.                     {k=0;}
  607.                 j++;
  608.                 }
  609.             if(k && i!=found && sector!=osector) return i;
  610.             }
  611.         }
  612.     return -1;
  613.     }
  614.  
  615. htoi(strng)
  616.     char *strng;
  617.     {
  618.     int value,i,mult;
  619.  
  620.     value = 0;
  621.     mult = 1;
  622.     i=strlen(strng)-1;
  623.     while(i > -1)
  624.         {
  625.         if(isalpha(strng[i]))
  626.             value += (toupper(strng[i]) - 0x37) * mult;
  627.         else value += (strng[i] - 0x30) * mult;
  628.         mult *= 16;
  629.         i--;
  630.         }
  631.     return value;
  632.     }
  633.  
  634. spaces(dist)
  635.     int dist;
  636.     {
  637.     while(dist--)
  638.         {
  639.         putc(' ',0);
  640.         }
  641.     }
  642.  
  643. nline()        /* new, clear line */
  644.     {
  645.     locate(22,0);
  646.     spaces(70);
  647.     putc(13,0);
  648.     }
  649.  
  650. oline()        /* new, clear line */
  651.     {
  652.     locate(23,0);
  653.     spaces(70);
  654.     putc(13,0);
  655.     }
  656.  
  657. chngdr()    /* bdos call to change logged drive */
  658.     {
  659.     #asm
  660.     POP    H
  661.     POP    D
  662.     PUSH    D
  663.     PUSH    H
  664.     MVI    C,14
  665.     JMP    5
  666.     #endasm
  667.     }
  668.  
  669. time()
  670.     {
  671. #asm
  672.     PUSH    PSW
  673.     MVI    A,0FFH
  674. SAMPLE:    DCR    A
  675.     CPI    0
  676.     JNZ    SAMPLE
  677.     POP    PSW
  678. #endasm
  679.     }
  680.  
  681. settrk()    /* bios call to set track number */
  682.     {
  683.     #asm
  684.     POP    H
  685.     POP    B
  686.     PUSH    B
  687.     PUSH    H
  688.     LXI    D,27
  689.     LHLD    0001
  690.     DAD    D
  691.     PCHL
  692.     #endasm
  693.     }
  694.  
  695. setsec()    /* bios call to set sector number */
  696.     {
  697.     #asm
  698.     POP    H
  699.     POP    B
  700.     PUSH    B
  701.     PUSH    H
  702.     LXI    D,30
  703.     LHLD    0001
  704.     DAD    D
  705.     PCHL
  706.     #endasm
  707.     }
  708.  
  709. readsec()    /* bios call to read sector */
  710.     {
  711.     #asm
  712.     LXI    D,36
  713.     LHLD    0001
  714.     DAD    D
  715.     PCHL
  716.     #endasm
  717.     }
  718.  
  719. #include stdlib.c
  720.